#!/usr/bin/env python
# -*- coding: utf-8 -*-

import logging
from typing import Optional, Dict, Any

from vector_store.vector_store_interface import VectorStoreInterface
from vector_store.sqlite_vector_store import SQLiteVectorStore
from vector_store.milvus_vector_store import MilvusVectorStore

# 导入全局配置
from config.config import config

# 获取logger
logger = logging.getLogger(__name__)

class VectorStoreFactory:
    """
    向量存储工厂类，用于创建不同类型的向量存储实现
    """
    
    # 已注册的向量存储实现
    REGISTERED_STORES = {
        "sqlite": SQLiteVectorStore,
        "milvus": MilvusVectorStore
    }
    
    @classmethod
    def register_store(cls, name: str, store_class: type) -> None:
        """
        注册新的向量存储实现
        
        Args:
            name: 存储实现的名称
            store_class: 存储实现的类
        """
        if not issubclass(store_class, VectorStoreInterface):
            raise TypeError(f"{store_class.__name__} 必须实现 VectorStoreInterface 接口")
        
        cls.REGISTERED_STORES[name] = store_class
        logger.info(f"向量存储实现已注册: {name}")
    
    @classmethod
    def create_vector_store(cls, config_dict: Optional[Dict[str, Any]] = None) -> VectorStoreInterface:
        """
        创建向量存储实例
        
        Args:
            config_dict: 可选的自定义向量存储配置参数。如果为None，将从全局配置获取
            
        Returns:
            向量存储实例
            
        Raises:
            ValueError: 如果指定的存储类型未注册或配置无效
        """
        # 从全局配置获取存储类型
        store_type = config.vector_store_type
        logger.debug(f"从全局配置获取存储类型: {store_type}")
        
        # 检查存储类型是否有效
        if store_type not in cls.REGISTERED_STORES:
            available_types = ", ".join(cls.REGISTERED_STORES.keys())
            raise ValueError(f"未知的向量存储类型: {store_type}，可用类型: {available_types}")
        
        # 准备配置
        store_config = {}
        
        # 如果提供了自定义配置，使用自定义配置
        if config_dict:
            store_config.update(config_dict)
            logger.debug("使用自定义配置创建向量存储")
        # 否则从全局配置获取
        else:
            if store_type == "sqlite":
                store_config.update(config.sqlite_config)
                logger.debug("从全局配置获取SQLite配置")
            elif store_type == "milvus":
                store_config.update(config.milvus_config)
                logger.debug("从全局配置获取Milvus配置")
        
        # 从嵌入配置获取API密钥和其他必要参数
        embedding_config = config.get_embedding_config()
        
        
        logger.debug(f"嵌入模型配置: api_key=*****, api_base={embedding_config.get('api_base')}, model_name={embedding_config.get('model_name')}")
        
        # 验证参数
        if store_type == "sqlite":
            # SQLite必须有db_path参数
            if 'db_path' not in store_config:
                raise ValueError("使用SQLite存储时，必须提供db_path参数")
            logger.info(f"使用SQLite数据库: {store_config['db_path']}")
        elif store_type == "milvus":
            # Milvus可以使用uri+token或db_path
            if 'uri' in store_config:
                # 使用远程连接方式
                if 'db_path' in store_config:
                    logger.warning("同时提供了uri和db_path参数，将优先使用uri连接")
                    store_config.pop('db_path')
                logger.info(f"使用Milvus远程连接: {store_config['uri']}")
            elif 'db_path' in store_config:
                # 使用本地数据库方式
                logger.info(f"使用Milvus本地数据库: {store_config['db_path']}")
            else:
                raise ValueError("使用Milvus存储时，必须提供uri或db_path参数")
        
        store_class = cls.REGISTERED_STORES[store_type]
        logger.info(f"创建向量存储: {store_type}")
        
        # 创建存储实例
        return store_class(**store_config) 